// 这道题, 我们使用dfs的方式, 比较树的子级之间耗时最长, 本质上就是一个递归
// 好像不需要多余的变量, 需要的依赖关系和启动时间, 都可以在矩阵中找到
// 现在有个疑问, 那就是? 服务集群, 的启动先后顺序?
// 也就是说, 我们使用深搜, 如果某一台服务器, 存在交叉使用会怎样呢? 思考下, 是否有这种可能性
// 由于服务器的启动有依赖关系, 所以, 只要不是到最后一台, 都需要待命状态, 所以, 从末尾开始
// 如果两个分叉中, 都调用了同一台服务器, 在第一个分叉中, 已经启动了它, 在第二个分叉中,
// 这台服务器将不占用时间? 不对吧, 又没规定, 只能深度单分支启动, 所以可以认为是同时启动多分支
// 这样就可以简化为, 评判单分支的启动时间, 如果他们之间有交集的话?  不知道原文中 服务之间启动没有循环依赖（不会出现环
// 这句话是否适用当前的场景, 显然是不适应的, 它表示的环指的是循环依赖, 当前这种不适应, 粗略分析,不影响递归
const readline = require("readline");
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
let n;
let initArr = [];
let start;
rl.on("line", (line)=>{
    if(n === undefined) {
        n = Number(line.trim());
    } else if (initArr.length !== n) {
        initArr.push(line.trim().split(" ").map(Number))
    } else if (start === undefined) {
        start = Number(line.trim()) - 1;
        console.log(getResult(n, start, initArr));

        // clear
        n = undefined;
        initArr.length = 0;
        start = undefined;
    }
})

/**
 *  计算目标服务器启动需要时间
 * @param n {number} 服务器数量
 * @param start {number} 启动服务器
 * @param initArr {[[number]]} 服务器之间依赖关系
 * @return {number}
 */
function getResult(n, start, initArr) {
    const timeUsed = {} // 缓存
    return dfs(start, initArr, timeUsed)
}

function dfs(start, initArr, timeUsed) {
    if(timeUsed.hasOwnProperty(start)) {
        return timeUsed[start]
    }

    let arr = initArr[start];
    let startSelf = arr[start];
    let startChild = 0;
    for (let i = 0; i < arr.length; i++) {
        if(i === start) continue;
        if(arr[i] === 1)  { // 有依赖关系
            startChild = Math.max(dfs(i, initArr, timeUsed), startChild)
        }
    }
    timeUsed[start] = startSelf + startChild;
    return timeUsed[start]
}